package com.ftg.learn.chapter05;

import com.ftg.learn.chapter04.isa.Dog;

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 学习集合
 *
 * @author 布衣
 */
public class LearnCollection {

    // 集合
    //   Collection      Map
    // list  set  queue

    //第一题  ：
    //线性存储结构 :
//    List 集合里面的常见方法自我理解 一下
//     ArrayList  linkedlist  vector

    public static void main(String[] args) {

        // 表示是否支持迭代功能
//        Iterable

        //迭代器
//        Iterator

        List<Dog> t = new ArrayList<>();

        //FunctionalInterface 函数式接口
        //Comparator 比较器
        Comparator<Dog> com = new Comparator<Dog>() {
            @Override
            public int compare(Dog o1, Dog o2) {
                return o1.getAge() - o2.getAge();
            }
        };

        //函数式接口 lambda
        Comparator<Dog> com1 = (x, y) -> x.getAge() - y.getAge();

        //叫做函数式调用
        Comparator<Dog> com2 = Comparator.comparingInt(Dog::getAge);

        Dog d1 = new Dog();
        d1.setAge(23);
        Dog d2 = new Dog();
        d2.setAge(34);
        Dog d3 = new Dog();
        d3.setAge(3);


        int compare = com1.compare(d1, d2);
        System.out.println(compare);

        // lambda 表达式 : 语法糖
        /*
         * ()->{}
         * 参数->{}
         * (参数，参数)->{}
         * x->x+3;
         */
        t.add(d2);
        t.add(d3);
        t.add(d1);
        t.sort(com1);

        System.out.println(t);
        List<Integer> list2 = new ArrayList<>();
        list2.add(3);
        list2.add(4);
        list2.add(5);

        List<Integer> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(2);
        list1.add(3);
        list1.add(4);
        list1.add(5);
        list1.addAll(list2);

        System.out.println(list1);
        ArrayList<Integer> l3 = new ArrayList<>(3);


        l3 = (ArrayList<Integer>) list1;
        l3.trimToSize();

        list1 = l3;

        List<Integer> list4 = new LinkedList<>();

        List<String> list5 = new ArrayList<>();
        list5.add("ac");
        list5.add("ax");
        list5.add("ay");
        list5.add("az");
        list5.add("b");
        list5.add("c");
        list5.add("d");
        list5.add("ad");

//        遍历
        System.out.println("普通 for");
        for (int i = 0; i < list5.size(); i++) {
            System.out.print(list5.get(i) + "\t");
        }

        System.out.println("增强型for");
        for (String item : list5) {
            System.out.println(item + "\t");
        }

        //foreach参数为 : consumer [消费者 (函数式接口（四大函数接口之一）)]
        System.out.println("foreach ---- 1 内部类");
        list5.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.print(s + "\t");
            }
        });
        System.out.println();
        System.out.println("foreach ----- 2 lambda");
        list5.forEach(x-> System.out.print(x + "\t"));

        System.out.println("foreach --- 3 函数 调用");
        list5.forEach(System.out::println);

        System.out.println("迭代器");

        for(Iterator<String> iterator = list5.iterator();iterator.hasNext();){
            String str = iterator.next();
            System.out.println(str);
        }

        Iterator<String> it = list5.iterator();

        while(it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("list  一些特殊使用方式");
//
//        for (int i = 0; i < list5.size(); i++) {
//            if (list5.get(i).startsWith("a")) {
//                list5.remove(i);
//                i-=1;
//            }
//        }
//


        //   Predicate 断言型函数式接口 {四大函数接口之一}
//        list5.removeIf(x->x.startsWith("a"));
        System.out.println(list5);


        //全新内容 : 集合的全新操作方式  Stream  产生一个全新的流地址，流里面存储的是集合内容

        //三部分组成  ：IO
        //开端 (创建)  list5.stream();
        //执行 (中间操作)   stream.filter(x->x.startsWith("a"))
        //结束 (结束 ) 
        Stream<String> stream = list5.stream();
        long a = stream.filter(x -> x.startsWith("a")).count();
        System.out.println(a);

        System.out.println(list5.stream().filter(x -> x.startsWith("a")).count());

        //链式调用  ：

        List<String> a1 = list5.stream().filter(x -> x.startsWith("a")).skip(0).limit(2).collect(Collectors.toList());

//        String str = "abc";
//        //可变自符序列
//        StringBuilder sb  = new StringBuilder("XXX");
//        sb.append("a").append("b").append("c");

        System.out.println(a1);

        Collection<String> str = new ArrayList<>();

        List<String> list6 = new LinkedList<>();
        //尾插法
        list6.add("a");
        list6.add("b");
        list6.add("c");

        list6.add(6,"x");
        System.out.println(list6);

    }

}
